// 题目描述
// 某国为促进城市间经济交流，决定对货物运输提供补贴。共有 n 个编号为 1 到 n 的城市，通过道路网络连接，网络中的道路仅允许从某个城市单向通行到另一个城市，不能反向通行。
// 网络中的道路都有各自的运输成本和政府补贴，道路的权值计算方式为：运输成本 - 政府补贴。权值为正表示扣除了政府补贴后运输货物仍需支付的费用；权值为负则表示政府的补贴超过了支出的运输成本，实际表现为运输过程中还能赚取一定的收益。
// 请计算在最多经过 k 个城市的条件下，从城市 src 到城市 dst 的最低运输成本。

// 输入描述
// 第一行包含两个正整数，第一个正整数 n 表示该国一共有 n 个城市，第二个整数 m 表示这些城市中共有 m 条道路。
// 接下来为 m 行，每行包括三个整数，s、t 和 v，表示 s 号城市运输货物到达 t 号城市，道路权值为 v。
// 最后一行包含三个正整数，src、dst、和 k，src 和 dst 为城市编号，从 src 到 dst 经过的城市数量限制。

// 输出描述
// 输出一个整数，表示从城市 src 到城市 dst 的最低运输成本，如果无法在给定经过城市数量限制下找到从 src 到 dst 的路径，则输出 "unreachable"，表示不存在符合条件的运输方案。

// 输入示例
// 6 7
// 1 2 1
// 2 4 -3
// 2 5 2
// 1 3 5
// 3 5 1
// 4 6 4
// 5 6 -2
// 2 6 1
// 输出示例
// 0

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void async function () {
    line = await readline();
    let [n, m] = line.split(' ').map(Number),
        graph = [],
        minDist = new Array(n + 1).fill(Number.MAX_VALUE);

    while (m-- > 0) {
        line = await readline()
        graph.push(line.split(' ').map(Number))
    }
    line = await readline()
    let [start, end, k] = line.split(' ').map(Number)

    minDist[start] = 0;
    let minDistCopy; // 用来记录上一次遍历的结果

    for (let i = 0; i < k + 1; i++) {
        minDistCopy = minDist.slice();
        for (let [left, right, val] of graph) {
            // 使用 minDist_copy 来计算 minDist 
            if (minDistCopy[left] !== Number.MAX_VALUE && minDistCopy[left] + val < minDist[right]) {
                minDist[right] = minDistCopy[left] + val
            }
        }
    }

    console.log(minDist[end] === Number.MAX_VALUE ? "unreachable" : minDist[end])
}()



void async function () {
    line = await readline();
    let [n, m] = line.split(' ').map(Number),
        graph = new Array(n + 1).fill(0).map(() => new Array()),
        minDist = new Array(n + 1).fill(Number.MAX_VALUE);

    while (m-- > 0) {
        line = await readline()
        let [left, right, val] = line.split(' ').map(Number)
        graph[left].push(new Edge(right, val))
    }
    line = await readline()
    let [start, end, k] = line.split(' ').map(Number),
        queue = [start];

    minDist[start] = 0;
    let minDistCopy 
    while (k-- >= 0 && queue.length > 0) {
        let len = queue.length,
            inQueue = new Array(n + 1).fill(false);
        minDistCopy = minDist.slice()
        while (len-- > 0) {
            let node = queue.shift();
            inQueue[node] = false
            for (let edgeItem of graph[node]) {
                if (minDistCopy[node] + edgeItem.val < minDist[edgeItem.to]) {
                    minDist[edgeItem.to] = minDistCopy[node] + edgeItem.val
                    if (inQueue[edgeItem.to] === false) {
                        queue.push(edgeItem.to)
                        inQueue[edgeItem.to] = true
                    }
                }
            }
        }
    }

    console.log(minDist[end] === Number.MAX_VALUE ? "unreachable" : minDist[end])
}()

class Edge {
    constructor(to, val) {
        this.to = to;
        this.val = val;
    }
}